In many computer system implementations, it is desirable to configure a plurality of nodes to behave as a resource grid. Doing so makes it possible for the individual nodes to contribute its resource or resources to a resource pool. Once the resource grid is set up, the resources in the resource pool may be called upon by external components. Any type of resource may be pooled in this way, including but not limited to storage resources and processing resources.
Typically, a resource grid comprises a plurality of slave nodes and one or more master nodes. The slave nodes are the nodes that provide the resources, while the master node acts as the interface between the slave nodes and the external components. A node may be both a slave node and a master node; that is, the node may provide one or more resources and act as an interface between the slave nodes and the external components.
In fulfilling its role as an interface, a master node receives resource requests from external components. In response to a resource request, the master node determines which of the slave nodes to call upon to fulfill the request. In making this determination, the master node may take many factors into account including, for example, the current load on the slave nodes (this enables the master node to load balance across the slave nodes). Once a slave node is chosen, the master node forwards the resource request to the slave node for processing. In this manner, the master node coordinates use of the slave nodes, and acts as an access point for external components to access the resources provided by the slave nodes in the resource grid. Because the master node acts as an access point, the external components are shielded from the underlying structure and complexity of the resource grid. Thus, from the point of view of the external components, the resource grid appears as a single pool of resources accessible through the master node.
Resource grids have a number of advantageous properties. Because they can comprise any number of nodes, resource grids are generally quite scalable (more nodes can be added to increase the amount of resources in the resource pool). Resource grids are also fault tolerant. If a slave node goes down, the master node can simply stop using that slave node and forward requests to other slave nodes. Resource grids may also be load balanced so that all slave nodes have appropriate workloads to maximize efficiency. Because of these and other properties, it is desirable in many computing applications to implement a resource grid.
Currently, the process of implementing a resource grid is quite labor and time intensive from the standpoint of a system administrator. Specifically, the administrator has to perform a number of manual tasks on each node of a resource grid to enable that node to function as part of the resource grid. These manual tasks include, for example, manually accessing each node, loading grid participation software into each node, configuring and running grid participation software, and setting a node to be a slave node, a master node, or both. These manual tasks can require a significant amount of time to perform, and since they have to be performed on every node, the amount of administrator time required to set up an entire resource grid can be substantial, especially if the resource grid comprises a large number of nodes.